O que é o operador “->” em C ++?

-> não é um operador. Na verdade, são dois operadores separados, - e>.
O código da condicional diminui x, enquanto retorna o valor original (não decrementado) de x, e então compara o valor original com 0 usando o operador>.
Para melhor compreender, a declaração pode ser escrita da seguinte forma:
enquanto ((x--)> 0)
|
Ou para algo completamente diferente ... x slides para 0.
enquanto (x - \
\
\
\
> 0)
printf ("% d", x);
Não tão matemático, mas ... cada imagem vale mais que mil palavras ...
|
Esse é um operador muito complicado, então até o ISO / IEC JTC1 (Joint Technical Committee 1) colocou sua descrição em duas partes diferentes do padrão C ++.
Brincadeiras à parte, eles são dois operadores diferentes: - e> descritos respectivamente em §5.2.6 / 2 e §5.9 do Padrão C ++ 03.
|
É equivalente a
enquanto (x--> 0)
x-- (pós-decremento) é equivalente ax = x-1, portanto, o código se transforma em:
enquanto (x> 0) {
x = x-1;
// lógica
}
x--; // O pós-decremento feito quando x <= 0
|
x pode ir para zero ainda mais rápido na direção oposta:
int x = 10;
enquanto (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Você pode controlar a velocidade com uma flecha!
int x = 100;
enquanto (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Está
#include 
int main (void) {
int x = 10;
enquanto (x--> 0) {// x vai para 0
printf ("% d", x);
}
return 0;
}
Apenas o espaço faz as coisas parecerem engraçadas, - decrementa e> compara.
|
O uso de -> tem relevância histórica. Decrementar foi (e ainda é em alguns casos) mais rápido do que incrementar na arquitetura x86. Usar -> sugere que x vai para 0 e atrai aqueles com formação matemática.
|
enquanto (x--> 0)
é como isso é analisado.
|
Totalmente geek, mas vou usar isto:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
faça printf ("n é% d \ n", n) como (n -> 0);
return 0;
}
|
Um livro que li (não me lembro bem qual livro) afirmava: Os compiladores tentam analisar expressões para o maior token usando a regra esquerda direita.
Nesse caso, a expressão:
x -> 0
Analisa os maiores tokens:
token 1: x
token 2: -
token 3:>
ficha 4: 0
concluir: x--> 0
A mesma regra se aplica a esta expressão:
a ----- b
Depois de analisar:
token 1: a
token 2: -
token 3: -
token 4: -
token 5: b
concluir: (a -) - - b
Espero que isso ajude a entender a expressão complicada ^^
|
Isso é exatamente o mesmo que
enquanto (x--)
{
printf ("% d", x);
}
para números não negativos
|
De qualquer forma, agora temos um operador "vai para". "->" é fácil de ser lembrado como uma direção, e "enquanto x vai para zero" significa reto.
Além disso, é um pouco mais eficiente do que "for (x = 10; x> 0; x -)" em algumas plataformas.
|
Este código primeiro compara x e 0 e, em seguida, diminui x. (Também disse na primeira resposta: você está pós-decrementando x e, em seguida, comparando xe 0 com o operador>.) Veja a saída deste código:
9 8 7 6 5 4 3 2 1 0
Agora, primeiro comparamos e, em seguida, diminuímos vendo 0 na saída.
Se quisermos primeiro diminuir e depois comparar, use este código:
#include 
int main (vazio)
{
int x = 10;
enquanto (--x> 0) // x vai para 0
{
printf ("% d", x);
}
return 0;
}
Essa saída é:
9 8 7 6 5 4 3 2 1
|
Meu compilador imprimirá 9876543210 quando eu executar este código.
#include 
int main ()
{
int x = 10;
enquanto (x -> 0) // x vai para 0
{
std :: cout << x;
}
}
Como esperado. O while (x--> 0) na verdade significa while (x> 0). O x-- post diminui x.
enquanto (x> 0)
{
x--;
std :: cout << x;
}
é uma maneira diferente de escrever a mesma coisa.
É bom que o original se pareça com "enquanto x vai para 0".
|
Há um espaço faltando entre - e>. x é pós-decrementado, ou seja, diminuído após verificar a condição x> 0?
|
- é o operador de decremento e> é o operador maior que.
Os dois operadores são aplicados como um único, como ->.
|
É uma combinação de dois operadores. Primeiro - serve para diminuir o valor e> para verificar se o valor é maior que o operando à direita.
#include 
int main ()
{
int x = 10;
enquanto (x--> 0)
printf ("% d", x);
return 0;
}
O resultado será:
9 8 7 6 5 4 3 2 1 0
|
Na verdade, x é pós-decrescente e com essa condição está sendo verificada. Não é ->, é (x--)> 0
Nota: o valor de x é alterado depois que a condição é verificada, porque é pós-decrescente. Alguns casos semelhantes também podem ocorrer, por exemplo:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C e C ++ obedecem à regra de "mastigação máxima". Da mesma forma que a --- b é traduzido para (a--) - b, no seu caso x -> 0 é traduzido para (x -)> 0.
O que a regra diz essencialmente é que, indo da esquerda para a direita, as expressões são formadas tomando o máximo de caracteres que formarão uma expressão válida.
|
Por que toda complicação?
A resposta simples para a pergunta original é apenas:
#include 
int main ()
{
int x = 10;
enquanto (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Ele faz a mesma coisa. Não estou dizendo que você deveria fazer assim, mas faz a mesma coisa e teria respondido a pergunta em um post.
O x-- é apenas uma abreviatura para o acima, e> é apenas um operador normal maior que. Nenhum grande mistério!
Existem muitas pessoas tornando as coisas simples complicadas hoje em dia;)
|
De maneira convencional, definiríamos uma condição no laço while entre parênteses () e uma condição de terminação entre colchetes {}, mas -> define as duas ao mesmo tempo.
Por exemplo:
int abc (vazio)
{
int a = 5
while ((a--)> 0) // Decrementar e comparar ao mesmo tempo
{
// Código
}
}
Isso diminui ae executa o loop enquanto a for maior que 0.
Convencionalmente, seria como:
int abc (vazio)
{
int a = 5;
enquanto (a> 0)
{
uma--;
// Código
}
uma--;
}
Ambas as formas, fazemos a mesma coisa e alcançamos os mesmos objetivos.
|
(x -> 0) significa (x--> 0).
Você pode usar (x ->) Saída: 9 8 7 6 5 4 3 2 1 0
Você pode usar (- x> 0) Significa (--x> 0) Saída: 9 8 7 6 5 4 3 2 1
Você pode usar
(- \
\
x> 0)
Resultado: 9 8 7 6 5 4 3 2 1
Você pode usar
(\
\
x -> 0)
Saída: 9 8 7 6 5 4 3 2 1 0
Você pode usar
(\
\
x -> 0
\
\
)
Saída: 9 8 7 6 5 4 3 2 1 0
Você também pode usar
(
x
->
)
Saída: 9 8 7 6 5 4 3 2 1 0
Da mesma forma, você pode tentar vários métodos para executar este comando com sucesso.
|
Aqui - é o operador de decremento post unário.
enquanto (x--> 0) // x vai para 0
{
printf ("% d", x);
}
No início, a condição será avaliada como
(x> 0) // 10> 0
Agora, como a condição é verdadeira, ela entrará no loop com um valor decrementado
x-- // x = 9
É por isso que o primeiro valor impresso é 9
E assim por diante. No último loop x = 1, então a condição é verdadeira. De acordo com o operador unário, o valor mudou para x = 0 no momento da impressão.
Agora, x = 0, que avalia a condição (x> 0) como falsa e o loop while sai.
|
Este -> não é um operador de forma alguma. Temos um operador como ->, mas não como ->. É apenas uma interpretação errada de while (x--> 0), o que significa simplesmente que x tem o operador pós-decremento e este loop será executado até ser maior que zero.
Outra maneira simples de escrever este código seria while (x--). O loop while irá parar sempre que obtiver uma condição falsa e aqui há apenas um caso, ou seja, 0. Portanto, ele irá parar quando o valor x for diminuído para zero.
|
Questão altamente ativa. Ganhe 10 reputação para responder a esta pergunta. O requisito de reputação ajuda a proteger essa pergunta contra spam e atividades sem resposta.
Não é a resposta que você está procurando? Navegue por outras questões marcadas com operadores c ++ c que formatam códigos de conformidade com os padrões ou faça sua própria pergunta.